.TH std::pmr::set_default_resource 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::pmr::set_default_resource \- std::pmr::set_default_resource

.SH Synopsis
   Defined in header <memory_resource>
   std::pmr::memory_resource* set_default_resource(                       \fI(since C++17)\fP
   std::pmr::memory_resource* r ) noexcept;

   If r is not null, sets the default memory resource pointer to r; otherwise, sets the
   default memory resource pointer to std::pmr::new_delete_resource().

   The default memory resource pointer is used by certain facilities when an explicit
   memory resource is not supplied. The initial default memory resource pointer is the
   return value of std::pmr::new_delete_resource.

   This function is thread-safe. Every call to std::pmr::set_default_resource
   synchronizes with (see std::memory_order) the subsequent
   std::pmr::set_default_resource and std::pmr::get_default_resource calls.

.SH Return value

   Returns the previous value of the default memory resource pointer.

.SH Example


// Run this code

 #include <array>
 #include <cstddef>
 #include <cstdint>
 #include <iostream>
 #include <iterator>
 #include <memory_resource>
 #include <vector>

 class noisy_allocator : public std::pmr::memory_resource
 {
     void* do_allocate(std::size_t bytes, std::size_t alignment) override
     {
         std::cout << "+ Allocating " << bytes << " bytes @ ";
         void* p = std::pmr::new_delete_resource()->allocate(bytes, alignment);
         std::cout << p << '\\n';
         return p;
     }

     void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override
     {
         std::cout << "- Deallocating " << bytes << " bytes @ " << p << '\\n';
         return std::pmr::new_delete_resource()->deallocate(p, bytes, alignment);
     }

     bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
     {
         return std::pmr::new_delete_resource()->is_equal(other);
     }
 };

 int main()
 {
     constexpr int push_back_limit{16};
     noisy_allocator mem;
     std::pmr::set_default_resource(&mem);

     {
         std::cout << "Entering scope #1 (without buffer on stack)...\\n";
         std::cout << "Creating vector v...\\n";
         std::pmr::vector<std::uint16_t> v{1, 2, 3, 4};
         std::cout << "v.data() @ " << v.data() << '\\n';

         std::cout << "Requesting more...\\n";
         for (int i{0}; i != push_back_limit; ++i)
         {
             v.push_back(i);
             std::cout << "v.size(): " << v.size() << '\\n';
         }
         std::cout << "Exiting scope #1...\\n";
     }

     std::cout << '\\n';

     {
         std::cout << "Entering scope #2 (with buffer on stack)...\\n";

         std::uint8_t buffer[16];
         std::cout << "Allocating buffer on stack: " << sizeof buffer << " bytes @ "
                   << static_cast<void*>(buffer) << '\\n';
         std::pmr::monotonic_buffer_resource mem_res{std::data(buffer), std::size(buffer)};

         std::cout << "Creating vector v...\\n";
         std::pmr::vector<std::uint16_t> v{{1, 2, 3, 4}, &mem_res};
         std::cout << "v.data() @ " << v.data() << '\\n'; // equals to `buffer` address

         std::cout << "Requesting more...\\n";
         for (int i{0}; i != push_back_limit; ++i)
         {
             v.push_back(i);
             std::cout << "v.size(): " << v.size() << '\\n';
         }
         std::cout << "Exiting scope #2...\\n";
     }
 }

.SH Possible output:

 Entering scope #1 (without buffer on stack)...
 Creating vector v...
 + Allocating 8 bytes @ 0x1f75c30
 v.data() @ 0x1f75c30
 Requesting more...
 + Allocating 16 bytes @ 0x1f75c50
 - Deallocating 8 bytes @ 0x1f75c30
 v.size(): 5
 v.size(): 6
 v.size(): 7
 v.size(): 8
 + Allocating 32 bytes @ 0x1f75c70
 - Deallocating 16 bytes @ 0x1f75c50
 v.size(): 9
 v.size(): 10
 v.size(): 11
 v.size(): 12
 v.size(): 13
 v.size(): 14
 v.size(): 15
 v.size(): 16
 + Allocating 64 bytes @ 0x1f75ca0
 - Deallocating 32 bytes @ 0x1f75c70
 v.size(): 17
 v.size(): 18
 v.size(): 19
 v.size(): 20
 Exiting scope #1...
 - Deallocating 64 bytes @ 0x1f75ca0

 Entering scope #2 (with buffer on stack)...
 Allocating buffer on stack: 16 bytes @ 0x7fffbe9f8240
 Creating vector v...
 v.data() @ 0x7fffbe9f8240
 Requesting more...
 + Allocating 64 bytes @ 0x1f75ca0
 v.size(): 5
 v.size(): 6
 v.size(): 7
 v.size(): 8
 v.size(): 9
 v.size(): 10
 v.size(): 11
 v.size(): 12
 v.size(): 13
 v.size(): 14
 v.size(): 15
 v.size(): 16
 + Allocating 128 bytes @ 0x1f75cf0
 v.size(): 17
 v.size(): 18
 v.size(): 19
 v.size(): 20
 Exiting scope #2...
 - Deallocating 128 bytes @ 0x1f75cf0
 - Deallocating 64 bytes @ 0x1f75ca0

.SH See also

   get_default_resource gets the default std::pmr::memory_resource
   \fI(C++17)\fP              \fI(function)\fP
                        returns a static program-wide std::pmr::memory_resource that
   new_delete_resource  uses the global operator new and operator delete to allocate
   \fI(C++17)\fP              and deallocate memory
                        \fI(function)\fP
